WebAssembly WASI Network Interface: Socket Communication API - คู่มือฉบับสมบูรณ์

WebAssembly (Wasm) ได้กลายเป็นเทคโนโลยีปฏิวัติวงการสำหรับการสร้างแอปพลิเคชันที่มีประสิทธิภาพสูง พกพาสะดวก และปลอดภัย แม้ว่าจะออกแบบมาสำหรับเว็บในตอนแรก แต่ความสามารถของมันก็ขยายไปไกลกว่าเบราว์เซอร์อย่างมาก โดยมีการนำไปใช้ในคลาวด์คอมพิวติ้ง, เอดจ์คอมพิวติ้ง, อุปกรณ์ IoT และอื่นๆ อีกมากมาย ตัวขับเคลื่อนสำคัญที่ทำให้ Wasm เป็นที่ยอมรับอย่างกว้างขวางคือ WebAssembly System Interface (WASI) ซึ่งเป็นอินเทอร์เฟซมาตรฐานสำหรับโมดูล Wasm ในการโต้ตอบกับระบบปฏิบัติการพื้นฐาน

คู่มือฉบับสมบูรณ์นี้จะเจาะลึกอินเทอร์เฟซเครือข่าย WASI โดยเฉพาะอย่างยิ่งการมุ่งเน้นไปที่ API การสื่อสาร Socket เราจะสำรวจสถาปัตยกรรม, ประโยชน์, ข้อควรพิจารณาด้านความปลอดภัย และยกตัวอย่างการปฏิบัติจริงเพื่อช่วยให้คุณสร้างแอปพลิเคชันเครือข่ายที่แข็งแกร่งและพกพาสะดวกด้วย Wasm

WASI คืออะไร?

WASI เป็นระบบอินเทอร์เฟซแบบแยกส่วนสำหรับ WebAssembly มีเป้าหมายเพื่อให้เป็นวิธีที่ปลอดภัยและพกพาสะดวกสำหรับโมดูล Wasm ในการเข้าถึงทรัพยากรของระบบ เช่น ไฟล์, เครือข่าย และเวลา ก่อน WASI โมดูล Wasm ถูกจำกัดอยู่ในสภาพแวดล้อม sandbox ของเบราว์เซอร์ และมีการเข้าถึงโลกภายนอกอย่างจำกัด WASI เปลี่ยนแปลงสิ่งนี้โดยการจัดเตรียม API ที่เป็นมาตรฐาน ซึ่งช่วยให้โมดูล Wasm สามารถโต้ตอบกับระบบปฏิบัติการในลักษณะที่มีการควบคุมและปลอดภัย

เป้าหมายหลักของ WASI ได้แก่:

• ความสามารถในการพกพา: WASI จัดเตรียม API ที่ไม่ขึ้นกับแพลตฟอร์ม ช่วยให้โมดูล Wasm สามารถทำงานบนระบบปฏิบัติการและสถาปัตยกรรมต่างๆ ได้โดยไม่ต้องแก้ไข
• ความปลอดภัย: WASI ใช้โมเดลความปลอดภัยตามความสามารถ (capability-based security model) โดยโมดูล Wasm จะเข้าถึงทรัพยากรได้เฉพาะที่ได้รับอนุญาตอย่างชัดเจนเท่านั้น
• ความเป็นโมดูล: WASI ถูกออกแบบให้เป็นชุดอินเทอร์เฟซแบบแยกส่วน ช่วยให้นักพัฒนาสามารถเลือกฟังก์ชันการทำงานเฉพาะที่พวกเขาต้องการสำหรับแอปพลิเคชันของตนได้

WASI Network Interface

WASI Network Interface ช่วยให้โมดูล Wasm สามารถดำเนินการเกี่ยวกับเครือข่าย เช่น การสร้าง Socket, การเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกล, การส่งและรับข้อมูล และการรอรับการเชื่อมต่อขาเข้า สิ่งนี้เปิดโอกาสมากมายสำหรับแอปพลิเคชัน Wasm รวมถึง:

• การสร้างแอปพลิเคชันฝั่งเซิร์ฟเวอร์ด้วย Wasm
• การใช้งานโปรโตคอลและบริการเครือข่าย
• การสร้างแอปพลิเคชันฝั่งไคลเอนต์ที่โต้ตอบกับ API ระยะไกล
• การพัฒนาแอปพลิเคชัน IoT ที่สื่อสารกับอุปกรณ์อื่นๆ

ภาพรวมของ Socket Communication API

WASI Socket Communication API จัดเตรียมชุดฟังก์ชันสำหรับการจัดการ Socket และการดำเนินการเกี่ยวกับเครือข่าย ฟังก์ชันเหล่านี้คล้ายคลึงกับที่พบใน Socket API แบบดั้งเดิม เช่น ที่จัดเตรียมโดยระบบปฏิบัติการ POSIX แต่มีการเพิ่มข้อควรพิจารณาด้านความปลอดภัยและความสามารถในการพกพา

ฟังก์ชันหลักที่นำเสนอโดย WASI Socket API ได้แก่:

• การสร้าง Socket: การสร้างจุดปลาย Socket ใหม่ด้วย Address Family และ Socket Type ที่ระบุ
• การ Binding: การกำหนด Address ภายในให้กับ Socket
• การ Listening: การเตรียม Socket ให้พร้อมสำหรับการยอมรับการเชื่อมต่อขาเข้า
• การ Connecting: การสร้างการเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกล
• การ Accepting: การยอมรับการเชื่อมต่อขาเข้าบน Socket ที่กำลังรอรับ
• การส่งและรับข้อมูล: การส่งและรับข้อมูลผ่านการเชื่อมต่อ Socket
• การ Closing: การปิด Socket และคืนทรัพยากร

แนวคิดหลักและฟังก์ชันการเรียก

เรามาสำรวจแนวคิดหลักและฟังก์ชันการเรียกบางส่วนใน WASI Socket API โดยละเอียดมากขึ้น

1. การสร้าง Socket (sock_open)

ฟังก์ชัน sock_open สร้าง Socket ใหม่ รับอาร์กิวเมนต์สองรายการ:

• Address Family: ระบุ Address Family ที่จะใช้สำหรับ Socket (เช่น AF_INET สำหรับ IPv4, AF_INET6 สำหรับ IPv6)
• Socket Type: ระบุประเภทของ Socket ที่จะสร้าง (เช่น SOCK_STREAM สำหรับ TCP, SOCK_DGRAM สำหรับ UDP)

ฟังก์ชันนี้จะคืนค่า File Descriptor ที่แสดงถึง Socket ที่สร้างขึ้นใหม่

ตัวอย่าง (เชิงแนวคิด):

``` wasi_fd = sock_open(AF_INET, SOCK_STREAM); ```

2. การ Binding (sock_bind)

ฟังก์ชัน sock_bind กำหนด Address ภายในให้กับ Socket ซึ่งโดยทั่วไปจะทำก่อนการรอรับการเชื่อมต่อขาเข้าบน Server Socket ฟังก์ชันนี้รับอาร์กิวเมนต์สามรายการ:

• File Descriptor: File Descriptor ของ Socket ที่จะผูก (bind)
• Address: พอยน์เตอร์ไปยังโครงสร้าง sockaddr ที่มี Address ภายในและ Port ที่จะผูก
• Address Length: ความยาวของโครงสร้าง sockaddr

ตัวอย่าง (เชิงแนวคิด):

``` sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(8080); // Port 8080 addr.sin_addr.s_addr = INADDR_ANY; // รอรับบนทุกอินเทอร์เฟซ wasi_error = sock_bind(wasi_fd, &addr, sizeof(addr)); ```

3. การ Listening (sock_listen)

ฟังก์ชัน sock_listen เตรียม Socket ให้พร้อมสำหรับการยอมรับการเชื่อมต่อขาเข้า ซึ่งโดยทั่วไปจะทำหลังจากผูก Socket กับ Address ภายในและก่อนการยอมรับการเชื่อมต่อ ฟังก์ชันนี้รับอาร์กิวเมนต์สองรายการ:

• File Descriptor: File Descriptor ของ Socket ที่จะรอรับ (listen)
• Backlog: จำนวนการเชื่อมต่อที่ค้างอยู่สูงสุดที่สามารถจัดคิวสำหรับ Socket ได้

ตัวอย่าง (เชิงแนวคิด):

``` wasi_error = sock_listen(wasi_fd, 5); // อนุญาตให้มีการเชื่อมต่อค้างอยู่สูงสุด 5 รายการ ```

4. การ Connecting (sock_connect)

ฟังก์ชัน sock_connect สร้างการเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกล ซึ่งโดยทั่วไปจะทำโดยแอปพลิเคชันไคลเอนต์เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ ฟังก์ชันนี้รับอาร์กิวเมนต์สามรายการ:

• File Descriptor: File Descriptor ของ Socket ที่จะเชื่อมต่อ
• Address: พอยน์เตอร์ไปยังโครงสร้าง sockaddr ที่มี Address ระยะไกลและ Port ที่จะเชื่อมต่อ
• Address Length: ความยาวของโครงสร้าง sockaddr

ตัวอย่าง (เชิงแนวคิด):

``` sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(80); // Port 80 inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr); // เชื่อมต่อไปยัง localhost wasi_error = sock_connect(wasi_fd, &addr, sizeof(addr)); ```

5. การ Accepting (sock_accept)

ฟังก์ชัน sock_accept ยอมรับการเชื่อมต่อขาเข้าบน Socket ที่กำลังรอรับ ซึ่งโดยทั่วไปจะทำโดยแอปพลิเคชันเซิร์ฟเวอร์เพื่อจัดการกับการเชื่อมต่อไคลเอนต์ใหม่ ฟังก์ชันนี้รับอาร์กิวเมนต์หนึ่งรายการ:

• File Descriptor: File Descriptor ของ Socket ที่กำลังรอรับ (listening)

ฟังก์ชันนี้จะคืนค่า File Descriptor ใหม่ที่แสดงถึงการเชื่อมต่อที่ยอมรับแล้ว File Descriptor ใหม่นี้สามารถใช้เพื่อส่งและรับข้อมูลกับไคลเอนต์ได้

ตัวอย่าง (เชิงแนวคิด):

``` client_fd = sock_accept(wasi_fd); ```

6. การส่งและรับข้อมูล (sock_send, sock_recv)

ฟังก์ชัน sock_send และ sock_recv ใช้สำหรับการส่งและรับข้อมูลผ่านการเชื่อมต่อ Socket ฟังก์ชันเหล่านี้รับอาร์กิวเมนต์ดังต่อไปนี้ (มุมมองแบบย่อ):

• File Descriptor: File Descriptor ของ Socket ที่จะส่งหรือรับข้อมูล
• Buffer: พอยน์เตอร์ไปยังบัฟเฟอร์ที่มีข้อมูลที่จะส่งหรือรับ
• Length: จำนวนไบต์ที่จะส่งหรือรับ

ตัวอย่าง (เชิงแนวคิด):

``` char buffer[1024]; size_t bytes_sent = sock_send(client_fd, buffer, 1024); size_t bytes_received = sock_recv(client_fd, buffer, 1024); ```

7. การ Closing (sock_close)

ฟังก์ชัน sock_close ปิด Socket และคืนทรัพยากร ฟังก์ชันนี้รับอาร์กิวเมนต์หนึ่งรายการ:

• File Descriptor: File Descriptor ของ Socket ที่จะปิด

ตัวอย่าง (เชิงแนวคิด):

``` wasi_error = sock_close(wasi_fd); ```

ข้อควรพิจารณาด้านความปลอดภัย

ความปลอดภัยเป็นข้อกังวลที่สำคัญที่สุดเมื่อต้องจัดการกับแอปพลิเคชันเครือข่าย WASI จัดการเรื่องนี้โดยใช้โมเดลความปลอดภัยตามความสามารถ (capability-based security model) ซึ่งหมายความว่าโมดูล Wasm จะเข้าถึงทรัพยากรได้เฉพาะที่ได้รับอนุญาตอย่างชัดเจนเท่านั้น สิ่งนี้ช่วยป้องกันไม่ให้โมดูลที่เป็นอันตรายเข้าถึงข้อมูลที่ละเอียดอ่อนหรือดำเนินการที่ไม่ได้รับอนุญาต

ข้อควรพิจารณาด้านความปลอดภัยที่สำคัญสำหรับ WASI Network Interface ได้แก่:

• ความปลอดภัยตามความสามารถ (Capability-Based Security): โมดูล Wasm จะต้องได้รับอนุญาตอย่างชัดเจนในการเข้าถึงเครือข่าย โดยทั่วไปจะทำผ่านกลไกที่คล้ายกับ File Descriptors ซึ่งโมดูลจะได้รับ Handle ไปยัง Socket ที่สามารถใช้ดำเนินการเกี่ยวกับเครือข่ายได้
• Sandboxing: โมดูล Wasm ทำงานในสภาพแวดล้อม Sandbox ซึ่งจำกัดการเข้าถึงระบบโฮสต์ สิ่งนี้ช่วยป้องกันไม่ให้โมดูลที่เป็นอันตรายหลุดออกจาก Sandbox และเป็นอันตรายต่อระบบโฮสต์
• การแยก Address Space: โมดูล Wasm แต่ละตัวมี Address Space ของตนเองที่แยกจากกัน ซึ่งป้องกันไม่ให้เข้าถึงหน่วยความจำของโมดูลอื่นหรือระบบโฮสต์
• ข้อจำกัดด้านทรัพยากร: โมดูล Wasm สามารถถูกจำกัดทรัพยากร เช่น การใช้หน่วยความจำและเวลา CPU สิ่งนี้ช่วยป้องกันไม่ให้โมดูลที่เป็นอันตรายใช้ทรัพยากรมากเกินไปและส่งผลกระทบต่อประสิทธิภาพของระบบโฮสต์

ประเด็นด้านความปลอดภัยเฉพาะของ WASI Network Interface ได้แก่:

• การแก้ไข DNS: ความสามารถในการแก้ไขชื่อโดเมนนั้นเป็นช่องทางการโจมตีที่มีศักยภาพ การควบคุมการแก้ไข DNS (เช่น โดยการจำกัดโดเมนที่โมดูลสามารถแก้ไขได้) เป็นสิ่งสำคัญ
• การเชื่อมต่อขาออก: การจำกัด IP Address และ Port ที่โมดูล Wasm สามารถเชื่อมต่อได้เป็นสิ่งจำเป็นเพื่อป้องกันการเข้าถึงทรัพยากรเครือข่ายภายในโดยไม่ได้รับอนุญาต หรือเซิร์ฟเวอร์ภายนอกที่เป็นอันตราย
• Port ที่รอรับ: การอนุญาตให้โมดูล Wasm รอรับบน Port ใดๆ อาจเป็นความเสี่ยงด้านความปลอดภัยที่สำคัญ การใช้งาน WASI โดยทั่วไปจะจำกัด Port ที่โมดูลสามารถผูกได้

ตัวอย่างการปฏิบัติ

ลองดูตัวอย่างการใช้งาน WASI Network Interface ในภาษาโปรแกรมต่างๆ

ตัวอย่างที่ 1: Simple TCP Echo Server ใน Rust

ตัวอย่างนี้แสดง Simple TCP Echo Server ที่เขียนด้วย Rust ซึ่งใช้ WASI Network Interface โปรดทราบว่านี่เป็นตัวอย่างเชิงแนวคิดที่แสดงถึง *แนวคิด* และต้องใช้ WASI Rust bindings ที่เหมาะสมและ WASI runtime ในการรัน

```rust // นี่คือตัวอย่างที่ย่อส่วนและต้องใช้ WASI bindings ที่เหมาะสม fn main() -> Result<(), Box> { let addr = "0.0.0.0:8080"; let listener = TcpListener::bind(addr)?; println!("Listening on {}", addr); for stream in listener.incoming() { let mut stream = stream?; println!("New connection: {}", stream.peer_addr()?); let mut buffer = [0; 1024]; loop { let bytes_read = stream.read(&mut buffer)?; if bytes_read == 0 { break; } stream.write_all(&buffer[..bytes_read])?; } println!("Connection closed"); } Ok(()) } ```

คำอธิบาย:

1. โค้ดผูก TCP listener เข้ากับ Address 0.0.0.0:8080
2. จากนั้นเข้าสู่ลูป รับการเชื่อมต่อขาเข้า
3. สำหรับแต่ละการเชื่อมต่อ จะอ่านข้อมูลจากไคลเอนต์และส่งกลับไป
4. มีการจัดการข้อผิดพลาด (ใช้ Result) เพื่อความแข็งแกร่ง

ตัวอย่างที่ 2: Simple HTTP Client ใน C++

ตัวอย่างนี้แสดง Simple HTTP Client ที่เขียนด้วย C++ ซึ่งใช้ WASI Network Interface อีกครั้ง นี่เป็นตัวอย่างเชิงแนวคิดและต้องอาศัย C++ WASI bindings และ runtime

```cpp // นี่คือตัวอย่างที่ย่อส่วนและต้องใช้ WASI bindings ที่เหมาะสม #include #include #include // สำหรับ memset // สมมติว่ามีไลบรารีเครือข่าย C++ WASI อยู่ // #include int main() { std::string hostname = "example.com"; int port = 80; // สร้าง Socket (สมมติว่ามีประเภท wasi_socket_t และฟังก์ชัน sock_open) // wasi_socket_t socket = sock_open(AF_INET, SOCK_STREAM); // แก้ไขชื่อโฮสต์ (Placeholder - WASI อาจมีตัวแก้ไขชื่อ) // struct sockaddr_in server_address; // inet_pton(AF_INET, "93.184.216.34", &(server_address.sin_addr)); // IP ที่กำหนดไว้ล่วงหน้าสำหรับ example.com // server_address.sin_family = AF_INET; // server_address.sin_port = htons(port); // เชื่อมต่อไปยังเซิร์ฟเวอร์ (sock_connect) // if (sock_connect(socket, (struct sockaddr*)&server_address, sizeof(server_address)) != 0) { // std::cerr << "Error connecting to server" << std::endl; // return 1; // } // สร้าง HTTP request std::string request = "GET / HTTP/1.1\r\nHost: " + hostname + "\r\nConnection: close\r\n\r\n"; // ส่ง request (sock_send) // ssize_t bytes_sent = sock_send(socket, request.c_str(), request.length()); // รับ response (sock_recv) char buffer[4096]; std::string response; // ssize_t bytes_received; // while ((bytes_received = sock_recv(socket, buffer, sizeof(buffer))) > 0) { // response.append(buffer, bytes_received); // } std::cout << "HTTP Response:" << std::endl; // std::cout << response << std::endl; // ปิด Socket (sock_close) // sock_close(socket); return 0; } ```

คำอธิบาย:

1. โค้ดพยายามสร้าง Socket โดยใช้ sock_open
2. จากนั้น (ตามสมมติฐาน) จะแก้ไขชื่อโฮสต์เป็น IP Address
3. พยายามเชื่อมต่อกับเซิร์ฟเวอร์โดยใช้ sock_connect
4. สร้าง HTTP GET request และส่งโดยใช้ sock_send
5. รับ HTTP response โดยใช้ sock_recv และแสดงผลบนคอนโซล
6. สุดท้าย ปิด Socket โดยใช้ sock_close

หมายเหตุสำคัญ: ตัวอย่างเหล่านี้ย่อส่วนอย่างมากและมีไว้เพื่อแสดงให้เห็นเท่านั้น การใช้งานจริงจะต้องมีการจัดการข้อผิดพลาดที่เหมาะสม, การแก้ไข Address (อาจผ่าน WASI API แยกต่างหาก) และการจัดการข้อมูลที่แข็งแกร่งกว่านี้ นอกจากนี้ยังต้องมีไลบรารีเครือข่ายที่เข้ากันได้กับ WASI ในภาษาที่เกี่ยวข้อง

ประโยชน์ของการใช้ WASI Network Interface

การใช้ WASI Network Interface มีข้อได้เปรียบหลายประการ:

• ความสามารถในการพกพา: โมดูล Wasm สามารถทำงานบนระบบปฏิบัติการและสถาปัตยกรรมต่างๆ ได้โดยไม่ต้องแก้ไข ทำให้ง่ายต่อการติดตั้งใช้งานแอปพลิเคชันในสภาพแวดล้อมที่หลากหลาย
• ความปลอดภัย: โมเดลความปลอดภัยตามความสามารถ (capability-based security model) ให้ชั้นความปลอดภัยที่แข็งแกร่ง ป้องกันไม่ให้โมดูลที่เป็นอันตรายเข้าถึงทรัพยากรที่ละเอียดอ่อนหรือดำเนินการที่ไม่ได้รับอนุญาต
• ประสิทธิภาพ: ประสิทธิภาพใกล้เคียง Native ของ Wasm ช่วยให้สามารถสร้างแอปพลิเคชันเครือข่ายที่มีประสิทธิภาพสูง
• ความเป็นโมดูล: การออกแบบ WASI แบบโมดูลช่วยให้นักพัฒนาสามารถเลือกฟังก์ชันการทำงานเฉพาะที่พวกเขาต้องการสำหรับแอปพลิเคชันของตน ลดขนาดและความซับซ้อนโดยรวมของโมดูล
• มาตรฐาน: WASI จัดเตรียม API ที่เป็นมาตรฐาน ทำให้ง่ายสำหรับนักพัฒนาในการเรียนรู้และใช้งาน และส่งเสริมความสามารถในการทำงานร่วมกันระหว่าง WASI runtimes ต่างๆ

ความท้าทายและทิศทางในอนาคต

แม้ว่า WASI Network Interface จะมีประโยชน์มากมาย แต่ก็มีความท้าทายบางประการที่ควรพิจารณา:

• ความสมบูรณ์: WASI Network Interface ยังค่อนข้างใหม่และอยู่ระหว่างการพัฒนาอย่างต่อเนื่อง API อาจมีการเปลี่ยนแปลงเมื่อเวลาผ่านไป และบางคุณสมบัติอาจยังไม่ได้รับการใช้งานอย่างเต็มที่
• การสนับสนุนไลบรารี: จำนวนไลบรารีเครือข่ายที่เข้ากันได้กับ WASI ที่มีคุณภาพยังคงมีจำกัด
• การดีบัก: การดีบักแอปพลิเคชัน Wasm ที่ใช้ WASI Network Interface อาจเป็นเรื่องท้าทาย เนื่องจากเครื่องมือดีบักแบบดั้งเดิมอาจไม่ได้รับการสนับสนุนอย่างเต็มที่
• การดำเนินการแบบอะซิงโครนัส: การรองรับการดำเนินการเครือข่ายแบบอะซิงโครนัสในรูปแบบมาตรฐานยังคงเป็นความพยายามอย่างต่อเนื่อง โซลูชันในปัจจุบันมักอาศัยการ polling หรือ callbacks ซึ่งอาจมีประสิทธิภาพน้อยกว่า I/O แบบอะซิงโครนัสที่แท้จริง

ทิศทางในอนาคตสำหรับ WASI Network Interface ได้แก่:

• การปรับปรุง API: การปรับปรุง API ตามความคิดเห็นจากนักพัฒนาและผู้ใช้งาน
• การเพิ่มคุณสมบัติใหม่: การเพิ่มการรองรับโปรโตคอลและฟังก์ชันเครือข่ายขั้นสูง
• การปรับปรุงเครื่องมือ: การพัฒนาเครื่องมือดีบักและโปรไฟล์ที่ดีขึ้นสำหรับแอปพลิเคชัน Wasm ที่ใช้ WASI Network Interface
• การเสริมสร้างความปลอดภัย: การทำให้โมเดลความปลอดภัยแข็งแกร่งขึ้นและจัดการกับช่องโหว่ที่อาจเกิดขึ้น
• Asynchronous I/O ที่เป็นมาตรฐาน: การพัฒนา API มาตรฐานสำหรับการดำเนินการเครือข่ายแบบอะซิงโครนัสใน WASI

สรุป

WebAssembly System Interface (WASI) Network Interface โดยเฉพาะอย่างยิ่ง Socket Communication API เป็นก้าวสำคัญในการทำให้ Wasm กลายเป็นแพลตฟอร์มที่พกพาได้และปลอดภัยอย่างแท้จริงสำหรับการสร้างแอปพลิเคชันเครือข่าย แม้ว่าจะยังอยู่ในช่วงการพัฒนา แต่ก็มีข้อได้เปรียบที่สำคัญในด้านความสามารถในการพกพา, ความปลอดภัย, ประสิทธิภาพ และความเป็นโมดูล

เมื่อระบบนิเวศ WASI เติบโตขึ้นและมีไลบรารีและเครื่องมือมากขึ้น เราคาดหวังว่าจะเห็นการยอมรับ Wasm อย่างกว้างขวางในแอปพลิเคชันที่ต้องใช้เครือข่าย ตั้งแต่แอปพลิเคชันฝั่งเซิร์ฟเวอร์และบริการเครือข่าย ไปจนถึงอุปกรณ์ IoT และ Edge Computing การทำความเข้าใจแนวคิด, ฟังก์ชันการทำงาน และข้อควรพิจารณาด้านความปลอดภัยของ WASI Network Interface นักพัฒนาสามารถใช้ประโยชน์จากพลังของ Wasm เพื่อสร้างแอปพลิเคชันเครือข่ายที่แข็งแกร่ง, พกพาได้ และปลอดภัยสำหรับผู้ชมทั่วโลก

คู่มือนี้เป็นพื้นฐานที่มั่นคงสำหรับการสำรวจ WASI Network Interface เรียนรู้ต่อไปด้วยการทดลองใช้ภาษาโปรแกรมต่างๆ, สำรวจ WASI implementations ที่มีอยู่ และติดตามข่าวสารล่าสุดเกี่ยวกับการพัฒนาใน WASI ecosystem